
/*
 * Copyright (C) Igor Sysoev
 * Copyright (C) Nginx, Inc.
 */


#include "ngx_event_timer.h"
#include <sys/time.h>

//#if (NGX_THREADS)
//ngx_mutex_t  *ngx_event_timer_mutex;
//#endif


ngx_thread_volatile ngx_rbtree_t  ngx_event_timer_rbtree;
static ngx_rbtree_node_t          ngx_event_timer_sentinel;
volatile ngx_msec_t      ngx_current_msec;

/*
 * the event timer rbtree may contain the duplicate keys, however,
 * it should not be a problem, because we use the rbtree to find
 * a minimum timer value only
 */

ngx_int_t
ngx_event_timer_init()
{
    ngx_rbtree_init(&ngx_event_timer_rbtree, &ngx_event_timer_sentinel,
                    ngx_rbtree_insert_timer_value);

//#if (NGX_THREADS)
//
//    if (ngx_event_timer_mutex) {
//        ngx_event_timer_mutex->log = log;
//        return NGX_OK;
//    }
//
//    ngx_event_timer_mutex = ngx_mutex_init(log, 0);
//    if (ngx_event_timer_mutex == NULL) {
//        return NGX_ERROR;
//    }
//
//#endif

    return 0;
}


ngx_msec_t
ngx_event_find_timer(void)
{
    ngx_msec_int_t      timer;
    ngx_rbtree_node_t  *node, *root, *sentinel;

    if (ngx_event_timer_rbtree.root == &ngx_event_timer_sentinel) {
        return NGX_TIMER_INFINITE;
    }

    //ngx_mutex_lock(ngx_event_timer_mutex);

    root = ngx_event_timer_rbtree.root;
    sentinel = ngx_event_timer_rbtree.sentinel;

    node = ngx_rbtree_min(root, sentinel);

    //ngx_mutex_unlock(ngx_event_timer_mutex);

    timer = (ngx_msec_int_t) (node->key - ngx_current_msec);

    return (ngx_msec_t) (timer > 0 ? timer : 0);
}


void
ngx_event_expire_timers(void)
{
    connection_t        *c;
    ngx_rbtree_node_t  *node, *root, *sentinel;

    sentinel = ngx_event_timer_rbtree.sentinel;

    for ( ;; ) {

        //ngx_mutex_lock(ngx_event_timer_mutex);

        root = ngx_event_timer_rbtree.root;

        if (root == sentinel) {
            return;
        }

        node = ngx_rbtree_min(root, sentinel);

        /* node->key <= ngx_current_time */

        if ((ngx_msec_int_t) (node->key - ngx_current_msec) <= 0) {
            c = (connection_t *) ((char *) node - offsetof(connection_t, timer));

//#if (NGX_THREADS)
//
//            if (ngx_threaded && ngx_trylock(ev->lock) == 0) {
//
//                /*
//                 * We cannot change the timer of the event that is being
//                 * handled by another thread.  And we cannot easy walk
//                 * the rbtree to find next expired timer so we exit the loop.
//                 * However, it should be a rare case when the event that is
//                 * being handled has an expired timer.
//                 */
//
//                ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
//                               "event %p is busy in expire timers", ev);
//                break;
//            }
//#endif

            //ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
            //               "event timer del: %d: %M",
            //               ngx_event_ident(ev->data), ev->timer.key);
            //
            ngx_rbtree_delete(&ngx_event_timer_rbtree, &c->timer);

            //ngx_mutex_unlock(ngx_event_timer_mutex);

#if (NGX_DEBUG)
            c->timer.left = NULL;
            c->timer.right = NULL;
            c->timer.parent = NULL;
#endif

            c->timer_set = 0;

//#if (NGX_THREADS)
//            if (ngx_threaded) {
//                ev->posted_timedout = 1;
//
//                ngx_post_event(ev, &ngx_posted_events);
//
//                ngx_unlock(ev->lock);
//
//                continue;
//            }
//#endif

            //c->timedout = 1;
            //
            //ev->handler(ev);
            handle_timer_event(c);

            continue;
        }

        break;
    }

    //ngx_mutex_unlock(ngx_event_timer_mutex);
}


void
ngx_time_update(void)
{
    time_t           sec;
    ngx_uint_t       msec;
    struct timeval   tv;

    gettimeofday(&tv, NULL);

    sec = tv.tv_sec;
    msec = tv.tv_usec / 1000;

    ngx_current_msec = (ngx_msec_t) sec * 1000 + msec;
}
